using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("DeckTrayDeckListContent")]
	public class DeckTrayDeckListContent : DeckTrayContent
	{
		public Transform m_deckEditTopPos => method_3<Transform>("m_deckEditTopPos");

		public Transform m_traySectionStartPos => method_3<Transform>("m_traySectionStartPos");

		public GameObject m_deckInfoTooltipBone => method_3<GameObject>("m_deckInfoTooltipBone");

		public GameObject m_deckOptionsBone => method_3<GameObject>("m_deckOptionsBone");

		public Vector3 m_deckButtonOffset => method_2<Vector3>("m_deckButtonOffset");

		public GameObject m_newDeckButtonContainer => method_3<GameObject>("m_newDeckButtonContainer");

		public CollectionNewDeckButton m_newDeckButton => method_3<CollectionNewDeckButton>("m_newDeckButton");

		public TraySection m_traySectionPrefab => method_3<TraySection>("m_traySectionPrefab");

		public string m_deckInfoActorPrefab => method_4("m_deckInfoActorPrefab");

		public string m_deckOptionsPrefab => method_4("m_deckOptionsPrefab");

		public UIBScrollable m_scrollbar => method_3<UIBScrollable>("m_scrollbar");

		public static float DECK_BUTTON_ROTATION_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckTrayDeckListContent", "DECK_BUTTON_ROTATION_TIME");

		public static int MAX_NUM_DECKBOXES_AVAILABLE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "DeckTrayDeckListContent", "MAX_NUM_DECKBOXES_AVAILABLE");

		public static int NUM_DECKBOXES_TO_DISPLAY => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "DeckTrayDeckListContent", "NUM_DECKBOXES_TO_DISPLAY");

		public static float TIME_BETWEEN_TRAY_DOOR_ANIMS => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckTrayDeckListContent", "TIME_BETWEEN_TRAY_DOOR_ANIMS");

		public static float DELETE_DECK_ANIM_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "DeckTrayDeckListContent", "DELETE_DECK_ANIM_TIME");

		public CollectionDeckInfo m_deckInfoTooltip => method_3<CollectionDeckInfo>("m_deckInfoTooltip");

		public bool m_initialized => method_2<bool>("m_initialized");

		public List<TraySection> m_traySections => method_3<Class271<TraySection>>("m_traySections")?.method_25();

		public TraySection m_editingTraySection => method_3<TraySection>("m_editingTraySection");

		public TraySection m_newlyCreatedTraySection => method_3<TraySection>("m_newlyCreatedTraySection");

		public bool m_animatingExit => method_2<bool>("m_animatingExit");

		public bool m_deletingDecks => method_2<bool>("m_deletingDecks");

		public bool m_wasTouchModeEnabled => method_2<bool>("m_wasTouchModeEnabled");

		public List<long> m_decksToDelete => method_3<Class270<long>>("m_decksToDelete")?.method_25();

		public string m_previousDeckName => method_4("m_previousDeckName");

		public int m_centeringDeckList => method_2<int>("m_centeringDeckList");

		public bool m_waitingToDeleteDeck => method_2<bool>("m_waitingToDeleteDeck");

		public DeckOptionsMenu m_deckOptionsMenu => method_3<DeckOptionsMenu>("m_deckOptionsMenu");

		public bool m_doneEntering => method_2<bool>("m_doneEntering");

		public Vector3 DeckButtonOffset => method_11<Vector3>("get_DeckButtonOffset", Array.Empty<object>());

		public DeckTrayDeckListContent(IntPtr address, string className)
			: base(address, className)
		{
		}

		public DeckTrayDeckListContent(IntPtr address)
			: this(address, "DeckTrayDeckListContent")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public bool IsDoneEntering()
		{
			return method_11<bool>("IsDoneEntering", Array.Empty<object>());
		}

		public new bool AnimateContentEntranceStart()
		{
			return method_11<bool>("AnimateContentEntranceStart", Array.Empty<object>());
		}

		public new bool AnimateContentEntranceEnd()
		{
			return method_11<bool>("AnimateContentEntranceEnd", Array.Empty<object>());
		}

		public new bool AnimateContentExitStart()
		{
			return method_11<bool>("AnimateContentExitStart", Array.Empty<object>());
		}

		public new bool AnimateContentExitEnd()
		{
			return method_11<bool>("AnimateContentExitEnd", Array.Empty<object>());
		}

		public new bool PreAnimateContentExit()
		{
			return method_11<bool>("PreAnimateContentExit", Array.Empty<object>());
		}

		public new bool PostAnimateContentExit()
		{
			return method_11<bool>("PostAnimateContentExit", Array.Empty<object>());
		}

		public new bool PreAnimateContentEntrance()
		{
			return method_11<bool>("PreAnimateContentEntrance", Array.Empty<object>());
		}

		public new void OnTaggedDeckChanged(CollectionManager.DeckTag tag, CollectionDeck newDeck, CollectionDeck oldDeck, bool isNewDeck)
		{
			method_8("OnTaggedDeckChanged", tag, newDeck, oldDeck, isNewDeck);
		}

		public void CreateNewDeckCancelled()
		{
			method_8("CreateNewDeckCancelled");
		}

		public bool IsWaitingToDeleteDeck()
		{
			return method_11<bool>("IsWaitingToDeleteDeck", Array.Empty<object>());
		}

		public int NumDecksToDelete()
		{
			return method_11<int>("NumDecksToDelete", Array.Empty<object>());
		}

		public bool IsDeletingDecks()
		{
			return method_11<bool>("IsDeletingDecks", Array.Empty<object>());
		}

		public void DeleteDeck(long deckID)
		{
			method_8("DeleteDeck", deckID);
		}

		public void DeleteEditingDeck()
		{
			method_8("DeleteEditingDeck");
		}

		public void CancelRenameEditingDeck()
		{
			method_8("CancelRenameEditingDeck");
		}

		public Vector3 GetNewDeckButtonPosition()
		{
			return method_11<Vector3>("GetNewDeckButtonPosition", Array.Empty<object>());
		}

		public void UpdateEditingDeckBoxVisual(string heroCardId)
		{
			method_8("UpdateEditingDeckBoxVisual", heroCardId);
		}

		public void OnDrawGizmos()
		{
			method_8("OnDrawGizmos");
		}

		public void RenameCurrentlyEditingDeck()
		{
			method_8("RenameCurrentlyEditingDeck");
		}

		public void UpdateDeckName(string deckName)
		{
			method_8("UpdateDeckName", deckName);
		}

		public void HideTraySectionsNotInBounds(Bounds bounds)
		{
			method_8("HideTraySectionsNotInBounds", bounds);
		}

		public CollectionDeck UpdateRenamingEditingDeck(string newDeckName)
		{
			return method_14<CollectionDeck>("UpdateRenamingEditingDeck", new object[1] { newDeckName });
		}

		public void FinishRenamingEditingDeck(string newDeckName)
		{
			method_8("FinishRenamingEditingDeck", newDeckName);
		}

		public void Initialize()
		{
			method_8("Initialize");
		}

		public void HideDeckInfoListener()
		{
			method_8("HideDeckInfoListener");
		}

		public void ShowDeckInfo()
		{
			method_8("ShowDeckInfo");
		}

		public void HideDeckInfo()
		{
			method_8("HideDeckInfo");
		}

		public void CreateTraySections()
		{
			method_8("CreateTraySections");
		}

		public void OnBoxTransitionFinished(object userData)
		{
			method_8("OnBoxTransitionFinished", userData);
		}

		public TraySection GetExistingTrayFromDeck(CollectionDeck deck)
		{
			return method_15<TraySection>("GetExistingTrayFromDeck", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { deck });
		}

		public TraySection GetExistingTrayFromDeck(long deckID)
		{
			return method_15<TraySection>("GetExistingTrayFromDeck", new Class276.Enum20[1] { Class276.Enum20.I8 }, new object[1] { deckID });
		}

		public TraySection GetEditingTraySection()
		{
			return method_14<TraySection>("GetEditingTraySection", Array.Empty<object>());
		}

		public void InitializeTraysFromDecks()
		{
			method_8("InitializeTraysFromDecks");
		}

		public void UpdateAllTrays(bool immediate, bool initializeTrays)
		{
			method_8("UpdateAllTrays", immediate, initializeTrays);
		}

		public void UpdateNewDeckButton(TraySection setNewDeckButtonPosition)
		{
			method_8("UpdateNewDeckButton", setNewDeckButtonPosition);
		}

		public bool UpdateNewDeckButtonPosition(TraySection setNewDeckButtonPosition)
		{
			return method_11<bool>("UpdateNewDeckButtonPosition", new object[1] { setNewDeckButtonPosition });
		}

		public TraySection GetLastUnusedTraySection()
		{
			return method_14<TraySection>("GetLastUnusedTraySection", Array.Empty<object>());
		}

		public TraySection GetLastUsedTraySection()
		{
			return method_14<TraySection>("GetLastUsedTraySection", Array.Empty<object>());
		}

		public TraySection GetTraySection(int index)
		{
			return method_14<TraySection>("GetTraySection", new object[1] { index });
		}

		public bool CanShowNewDeckButton()
		{
			return method_11<bool>("CanShowNewDeckButton", Array.Empty<object>());
		}

		public void SetEditingTraySection(int index)
		{
			method_8("SetEditingTraySection", index);
		}

		public bool IsEditingCards()
		{
			return method_11<bool>("IsEditingCards", Array.Empty<object>());
		}

		public void OnDeckBoxVisualOver(CollectionDeckBoxVisual deckBox)
		{
			method_8("OnDeckBoxVisualOver", deckBox);
		}

		public void OnDeckBoxVisualOut(CollectionDeckBoxVisual deckBox)
		{
			method_8("OnDeckBoxVisualOut", deckBox);
		}

		public void OnDeckBoxVisualPress(CollectionDeckBoxVisual deckBox)
		{
			method_8("OnDeckBoxVisualPress", deckBox);
		}

		public void OnDeckBoxVisualRelease(TraySection traySection)
		{
			method_8("OnDeckBoxVisualRelease", traySection);
		}

		public void OnNewDeckButtonPress()
		{
			method_8("OnNewDeckButtonPress");
		}

		public void StartCreateNewDeck()
		{
			method_8("StartCreateNewDeck");
		}

		public void EndCreateNewDeck(bool newDeck)
		{
			method_8("EndCreateNewDeck", newDeck);
		}

		public void DeleteQueuedDecks(bool force)
		{
			method_8("DeleteQueuedDecks", force);
		}

		public void OnDeckDeleted(long deckID)
		{
			method_8("OnDeckDeleted", deckID);
		}

		public void FireDeckCountChangedEvent()
		{
			method_8("FireDeckCountChangedEvent");
		}

		public void FireBusyWithDeckEvent(bool busy)
		{
			method_8("FireBusyWithDeckEvent", busy);
		}

		public int GetTotalDeckBoxesInUse()
		{
			return method_11<int>("GetTotalDeckBoxesInUse", Array.Empty<object>());
		}

		public void OnFavoriteHeroChanged(TAG_CLASS heroClass, NetCache.CardDefinition favoriteHero, object userData)
		{
			method_8("OnFavoriteHeroChanged", heroClass, favoriteHero, userData);
		}

		public int UpdateDeckTrayVisuals()
		{
			return method_11<int>("UpdateDeckTrayVisuals", Array.Empty<object>());
		}

		public void SwapEditTrayIfNeeded(long editDeckID)
		{
			method_8("SwapEditTrayIfNeeded", editDeckID);
		}
	}
}
